home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / JFC.bin / SwingUtilities.java < prev    next >
Text File  |  1998-06-30  |  51KB  |  1,376 lines
  1. /*
  2.  * @(#)SwingUtilities.java    1.54 98/06/23
  3.  *
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  *
  19.  */
  20. package com.sun.java.swing;
  21.  
  22. import java.applet.*;
  23.  
  24. import java.awt.*;
  25. import java.awt.event.*;
  26.  
  27. import java.util.Vector;
  28. import java.util.Hashtable;
  29.  
  30. import java.lang.reflect.*;
  31.  
  32. import com.sun.java.accessibility.*;
  33.  
  34.  
  35. /**
  36.  * A collection of utility methods for Swing.
  37.  *
  38.  * @version 1.54 06/23/98
  39.  */
  40. public class SwingUtilities implements SwingConstants {
  41.  
  42.     // These states are system-wide, rather than AppContext wide.
  43.     private static boolean canAccessEventQueue = false;
  44.     private static boolean eventQueueTested = false;
  45.  
  46.  
  47.     /** Return true if <code>a</code> contains <code>b</code> **/
  48.     public static final boolean isRectangleContainingRectangle(Rectangle a,Rectangle b) {
  49.         if (b.x >= a.x && (b.x + b.width) <= (a.x + a.width) &&
  50.             b.y >= a.y && (b.y + b.height) <= (a.y + a.height)) {
  51.             return true;
  52.         }
  53.         return false;
  54.     }
  55.  
  56.     /** Return the rectangle (0,0,bounds.width,bounds.height) for the component <code>aComponent</code>
  57.      */
  58.     public static Rectangle getLocalBounds(Component aComponent) {
  59.         Rectangle b = new Rectangle(aComponent.getBounds());
  60.         b.x = b.y = 0;
  61.         return b;
  62.     }
  63.  
  64.  
  65.     /** 
  66.      * @return the first Window ancestor of c
  67.      */
  68.     private static Window getWindowAncestor(Component c) {
  69.         for(Container p = c.getParent(); p != null; p = p.getParent()) {
  70.             if (p instanceof Window) {
  71.                 return (Window)p;
  72.         }
  73.         }
  74.         return null;
  75.     }
  76.  
  77.  
  78.     /** Convert a <code>aPoint</code> in <code>source</code> coordinate system to
  79.      *  <code>destination</code> coordinate system.
  80.      *  If <code>source></code>is null,<code>aPoint</code> is assumed to be in <code>destination</code>'s
  81.      *  root component coordinate system.
  82.      *  If <code>destination</code>is null, <code>aPoint</code> will be converted to <code>source</code>'s
  83.      *  root component coordinate system.
  84.      *  If both <code>source</code> and <code>destination</code> are null, return <code>aPoint</code>
  85.      *  without any conversion.
  86.      */
  87.     public static Point convertPoint(Component source,Point aPoint,Component destination) {
  88.         Point p;
  89.  
  90.         if(source == null && destination == null)
  91.             return aPoint;
  92.         if(source == null) {
  93.             source = getWindowAncestor(destination);
  94.             if(source == null)
  95.                 throw new Error("Source component not connected to component tree hierarchy");
  96.         }
  97.         p = new Point(aPoint);
  98.         convertPointToScreen(p,source);
  99.         if(destination == null) {
  100.             destination = getWindowAncestor(source);
  101.             if(destination == null)
  102.                 throw new Error("Destination component not connected to component tree hierarchy");
  103.         }
  104.         convertPointFromScreen(p,destination);
  105.         return p;
  106.     }
  107.  
  108.     /** Convert the point <code>(x,y)</code> in <code>source</code> coordinate system to
  109.      *  <code>destination</code> coordinate system.
  110.      *  If <code>source></code>is null,<code>(x,y)</code> is assumed to be in <code>destination</code>'s
  111.      *  root component coordinate system.
  112.      *  If <code>destination</code>is null, <code>(x,y)</code> will be converted to <code>source</code>'s
  113.      *  root component coordinate system.
  114.      *  If both <code>source</code> and <code>destination</code> are null, return <code>(x,y)</code>
  115.      *  without any conversion.
  116.      */
  117.     public static Point convertPoint(Component source,int x, int y,Component destination) {
  118.         Point point = new Point(x,y);
  119.         return convertPoint(source,point,destination);
  120.     }
  121.  
  122.     /** Convert the rectangle <code>aRectangle</code> in <code>source</code> coordinate system to
  123.      *  <code>destination</code> coordinate system.
  124.      *  If <code>source></code>is null,<code>aRectangle</code> is assumed to be in <code>destination</code>'s
  125.      *  root component coordinate system.
  126.      *  If <code>destination</code>is null, <code>aRectangle</code> will be converted to <code>source</code>'s
  127.      *  root component coordinate system.
  128.      *  If both <code>source</code> and <code>destination</code> are null, return <code>aRectangle</code>
  129.      *  without any conversion.
  130.      */
  131.     public static Rectangle convertRectangle(Component source,Rectangle aRectangle,Component destination) {
  132.         Point point = new Point(aRectangle.x,aRectangle.y);
  133.         point =  convertPoint(source,point,destination);
  134.         return new Rectangle(point.x,point.y,aRectangle.width,aRectangle.height);
  135.     }
  136.  
  137.     /** Convience method for searching above <code>comp</code> in the
  138.       * component hierarchy and returns the first object of class <code>c</code> it
  139.       * finds. Can return null, if a class <code>c</code> cannot be found.
  140.       */
  141.     public static Container getAncestorOfClass(Class c, Component comp) {
  142.         if(comp == null || c == null)
  143.             return null;
  144.  
  145.         Container parent = comp.getParent();
  146.         while(parent != null && !(c.isInstance(parent)))
  147.             parent = parent.getParent();
  148.         return parent;
  149.     }
  150.  
  151.     /** Convience method for searching above <code>comp</code> in the
  152.       * component hierarchy and returns the first object of <code>name</code> it
  153.       * finds. Can return null, if <code>name</code> cannot be found.
  154.       */
  155.     public static Container getAncestorNamed(String name, Component comp) {
  156.         if(comp == null || name == null)
  157.             return null;
  158.  
  159.         Container parent = comp.getParent();
  160.         while(parent != null && !(name.equals(parent.getName())))
  161.             parent = parent.getParent();
  162.         return parent;
  163.     }
  164.  
  165.     /**
  166.       * Returns the deepest child Component of parent that is at the location
  167.       * <code>x</code>, <code>y</code>. If <code>parent</code> is not a Container, it is
  168.       * returned, otherwise this method is messaged again with the child
  169.       * component at <code>x</code>, <code>y</code>.
  170.       */
  171.     public static Component getDeepestComponentAt(Component parent, int x,
  172.                                                   int y) {
  173.         if(parent != null && parent instanceof Container) {
  174.             Component child = ((Container)parent).getComponentAt(x, y);
  175.  
  176.             if(child != null && child != parent && child.isVisible()) {
  177.                 Rectangle b = child.getBounds();
  178.                 child = getDeepestComponentAt(child, x - b.x,y-b.y);
  179.                 if(child != null)
  180.                     return child;
  181.             }
  182.         }
  183.         return parent;
  184.     }
  185.  
  186.     /** Returns a MouseEvent similar to <code>sourceEvent</code> except that its x
  187.      * and y members have been converted to <code>destination</code>'s coordinate
  188.      * system.  If <code>source</code> is null, <code>sourceEvent</code> x and y members
  189.      * are assumed to be into <code>destination<code>'s root component coordinate system.
  190.      * If <code>destination</code> is <code>null</code>, the
  191.      * returned MouseEvent will be in <code>source</code>'s coordinate system.
  192.      * <code>sourceEvent</code> will not be changed. A new event is returned.
  193.      * the <code>source</code> field of the returned event will be set
  194.      * to <code>destination</code> if destination is non null
  195.      * use the translateMouseEvent() method to translate a mouse event from
  196.      * one component to another without changing the source.
  197.      */
  198.     public static MouseEvent convertMouseEvent(Component source,
  199.                                                MouseEvent sourceEvent,
  200.                                                Component destination) {
  201.         Point p = convertPoint(source,new Point(sourceEvent.getX(),
  202.                                                 sourceEvent.getY()),
  203.                                destination);
  204.         Component newSource;
  205.  
  206.         if(destination != null)
  207.             newSource = destination;
  208.         else
  209.             newSource = source;
  210.  
  211.         return new MouseEvent(newSource,
  212.                               sourceEvent.getID(),
  213.                               sourceEvent.getWhen(),
  214.                               sourceEvent.getModifiers(),
  215.                               p.x,p.y,
  216.                               sourceEvent.getClickCount(),
  217.                               sourceEvent.isPopupTrigger());
  218.     }
  219.  
  220.  
  221.     public static void convertPointToScreen(Point p,Component c) {
  222.             Rectangle b;
  223.             int x,y;
  224.  
  225.             do {
  226.                 if(c instanceof JComponent) {
  227.                     x = ((JComponent)c).getX();
  228.                     y = ((JComponent)c).getY();
  229.                 } else if(c instanceof java.applet.Applet) {
  230.                     Point pp = c.getLocationOnScreen();
  231.                     x = pp.x;
  232.                     y = pp.y;
  233.                 } else {
  234.                     b = c.getBounds();
  235.                     x = b.x;
  236.                     y = b.y;
  237.                 }
  238.  
  239.                 p.x += x;
  240.                 p.y += y;
  241.  
  242.                 if(c instanceof java.awt.Window || c instanceof java.applet.Applet)
  243.                     break;
  244.                 c = c.getParent();
  245.             } while(c != null);
  246.         }
  247.  
  248.     public static void convertPointFromScreen(Point p,Component c) {
  249.         Rectangle b;
  250.         int x,y;
  251.  
  252.         do {
  253.             if(c instanceof JComponent) {
  254.                 x = ((JComponent)c).getX();
  255.                 y = ((JComponent)c).getY();
  256.             }  else if(c instanceof java.applet.Applet) {
  257.                 Point pp = c.getLocationOnScreen();
  258.                 x = pp.x;
  259.                 y = pp.y;
  260.             } else {
  261.                 b = c.getBounds();
  262.                 x = b.x;
  263.                 y = b.y;
  264.             }
  265.  
  266.             p.x -= x;
  267.             p.y -= y;
  268.  
  269.             if(c instanceof java.awt.Window || c instanceof java.applet.Applet)
  270.                 break;
  271.             c = c.getParent();
  272.         } while(c != null);
  273.     }
  274.  
  275.     /** Return <code>aComponent</code>'s window **/
  276.     public static Window windowForComponent(Component aComponent) {
  277.         for (Container p = aComponent.getParent(); p != null; p = p.getParent()) {
  278.             if (p instanceof Window) {
  279.                 return (Window)p;
  280.             }
  281.         }
  282.         return null;
  283.     }
  284.  
  285.     /** Return <code>true</code> if a component <code>a</code> descends from a component <code>b</code>
  286.      */
  287.     public static boolean isDescendingFrom(Component a,Component b) {
  288.         if(a == b)
  289.             return true;
  290.         for(Container p = a.getParent();p!=null;p=p.getParent())
  291.             if(p == b)
  292.                 return true;
  293.         return false;
  294.     }
  295.  
  296.  
  297.     /**
  298.      * Convenience to calculate an intersection of two rectangles without allocating a new rectangle
  299.      * Return dest.
  300.      */
  301.     public static Rectangle computeIntersection(int x,int y,int width,int height,Rectangle dest) {
  302.         int x1 = (x > dest.x) ? x : dest.x;
  303.         int x2 = ((x+width) < (dest.x + dest.width)) ? (x+width) : (dest.x + dest.width);
  304.         int y1 = (y > dest.y) ? y : dest.y;
  305.         int y2 = ((y + height) < (dest.y + dest.height) ? (y+height) : (dest.y + dest.height));
  306.  
  307.         dest.x = x1;
  308.         dest.y = y1;
  309.         dest.width = x2 - x1;
  310.         dest.height = y2 - y1;
  311.         return dest;
  312.     }
  313.  
  314.     /**
  315.      * Convenience to calculate the union of two rectangles without allocating a new rectangle
  316.      * Return dest
  317.      */
  318.     public static Rectangle computeUnion(int x,int y,int width,int height,Rectangle dest) {
  319.         int x1 = (x < dest.x) ? x : dest.x;
  320.         int x2 = ((x+width) > (dest.x + dest.width)) ? (x+width) : (dest.x + dest.width);
  321.         int y1 = (y < dest.y) ? y : dest.y;
  322.         int y2 = ((y+height) > (dest.y + dest.height)) ? (y+height) : (dest.y + dest.height);
  323.  
  324.         dest.x = x1;
  325.         dest.y = y1;
  326.         dest.width = (x2 - x1);
  327.         dest.height= (y2 - y1);
  328.         return dest;
  329.     }
  330.  
  331.     /**
  332.      * Convenience returning an array of rect representing the regions within
  333.      * <code>rectA</code> that do not overlap with <code>rectB</code>. If the
  334.      * two Rects do not overlap, returns an empty array
  335.      */
  336.     public static Rectangle[] computeDifference(Rectangle rectA,Rectangle rectB) {
  337.         if (rectB == null || !rectA.intersects(rectB) || isRectangleContainingRectangle(rectB,rectA)) {
  338.             return new Rectangle[0];
  339.         }
  340.  
  341.         Rectangle t = new Rectangle();
  342.         Rectangle a=null,b=null,c=null,d=null;
  343.         Rectangle result[];
  344.         int rectCount = 0;
  345.  
  346.         /* rectA contains rectB */
  347.         if (isRectangleContainingRectangle(rectA,rectB)) {
  348.             t.x = rectA.x; t.y = rectA.y; t.width = rectB.x - rectA.x; t.height = rectA.height;
  349.             if(t.width > 0 && t.height > 0) {
  350.                 a = new Rectangle(t);
  351.                 rectCount++;
  352.             }
  353.  
  354.             t.x = rectB.x; t.y = rectA.y; t.width = rectB.width; t.height = rectB.y - rectA.y;
  355.             if(t.width > 0 && t.height > 0) {
  356.                 b = new Rectangle(t);
  357.                 rectCount++;
  358.             }
  359.  
  360.             t.x = rectB.x; t.y = rectB.y + rectB.height; t.width = rectB.width;
  361.             t.height = rectA.y + rectA.height - (rectB.y + rectB.height);
  362.             if(t.width > 0 && t.height > 0) {
  363.                 c = new Rectangle(t);
  364.                 rectCount++;
  365.             }
  366.  
  367.             t.x = rectB.x + rectB.width; t.y = rectA.y; t.width = rectA.x + rectA.width - (rectB.x + rectB.width);
  368.             t.height = rectA.height;
  369.             if(t.width > 0 && t.height > 0) {
  370.                 d = new Rectangle(t);
  371.                 rectCount++;
  372.             }
  373.         } else {
  374.             /* 1 */
  375.             if (rectB.x <= rectA.x && rectB.y <= rectA.y) {
  376.                 if ((rectB.x + rectB.width) > (rectA.x + rectA.width)) {
  377.  
  378.                     t.x = rectA.x; t.y = rectB.y + rectB.height;
  379.                     t.width = rectA.width; t.height = rectA.y + rectA.height - (rectB.y + rectB.height);
  380.                     if(t.width > 0 && t.height > 0) {
  381.                         a = t;
  382.                         rectCount++;
  383.                     }
  384.                 } else if ((rectB.y + rectB.height) > (rectA.y + rectA.height)) {
  385.                     t.setBounds((rectB.x + rectB.width), rectA.y,
  386.                                 (rectA.x + rectA.width) - (rectB.x + rectB.width), rectA.height);
  387.                     if(t.width > 0 && t.height > 0) {
  388.                         a = t;
  389.                         rectCount++;
  390.                     }
  391.                 } else {
  392.                     t.setBounds((rectB.x + rectB.width), rectA.y,
  393.                                 (rectA.x + rectA.width) - (rectB.x + rectB.width),
  394.                                 (rectB.y + rectB.height) - rectA.y);
  395.                     if(t.width > 0 && t.height > 0) {
  396.                         a = new Rectangle(t);
  397.                         rectCount++;
  398.                     }
  399.  
  400.                     t.setBounds(rectA.x, (rectB.y + rectB.height), rectA.width,
  401.                                 (rectA.y + rectA.height) - (rectB.y + rectB.height));
  402.                     if(t.width > 0 && t.height > 0) {
  403.                         b = new Rectangle(t);
  404.                         rectCount++;
  405.                     }
  406.                 }
  407.             } else if (rectB.x <= rectA.x && (rectB.y + rectB.height) >= (rectA.y + rectA.height)) {
  408.                 if ((rectB.x + rectB.width) > (rectA.x + rectA.width)) {
  409.                     t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  410.                     if(t.width > 0 && t.height > 0) {
  411.                         a = t;
  412.                         rectCount++;
  413.                     }
  414.                 } else {
  415.                     t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  416.                     if(t.width > 0 && t.height > 0) {
  417.                         a = new Rectangle(t);
  418.                         rectCount++;
  419.                     }
  420.                     t.setBounds((rectB.x + rectB.width), rectB.y,
  421.                                 (rectA.x + rectA.width) - (rectB.x + rectB.width),
  422.                                 (rectA.y + rectA.height) - rectB.y);
  423.                     if(t.width > 0 && t.height > 0) {
  424.                         b = new Rectangle(t);
  425.                         rectCount++;
  426.                     }
  427.                 }
  428.             } else if (rectB.x <= rectA.x) {
  429.                 if ((rectB.x + rectB.width) >= (rectA.x + rectA.width)) {
  430.                     t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  431.                     if(t.width>0 && t.height > 0) {
  432.                         a = new Rectangle(t);
  433.                         rectCount++;
  434.                     }
  435.  
  436.                     t.setBounds(rectA.x, (rectB.y + rectB.height), rectA.width,
  437.                                 (rectA.y + rectA.height) - (rectB.y + rectB.height));
  438.                     if(t.width > 0 && t.height > 0) {
  439.                         b = new Rectangle(t);
  440.                         rectCount++;
  441.                     }
  442.                 } else {
  443.                     t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  444.                     if(t.width > 0 && t.height > 0) {
  445.                         a = new Rectangle(t);
  446.                         rectCount++;
  447.                     }
  448.  
  449.                     t.setBounds((rectB.x + rectB.width), rectB.y,
  450.                                 (rectA.x + rectA.width) - (rectB.x + rectB.width),
  451.                                 rectB.height);
  452.                     if(t.width > 0 && t.height > 0) {
  453.                         b = new Rectangle(t);
  454.                         rectCount++;
  455.                     }
  456.  
  457.                     t.setBounds(rectA.x, (rectB.y + rectB.height), rectA.width,
  458.                                 (rectA.y + rectA.height) - (rectB.y + rectB.height));
  459.                     if(t.width > 0 && t.height > 0) {
  460.                         c = new Rectangle(t);
  461.                         rectCount++;
  462.                     }
  463.                 }
  464.             } else if (rectB.x <= (rectA.x + rectA.width) && (rectB.x + rectB.width) > (rectA.x + rectA.width)) {
  465.                 if (rectB.y <= rectA.y && (rectB.y + rectB.height) > (rectA.y + rectA.height)) {
  466.                     t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectA.height);
  467.                     if(t.width > 0 && t.height > 0) {
  468.                         a = t;
  469.                         rectCount++;
  470.                     }
  471.                 } else if (rectB.y <= rectA.y) {
  472.                     t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x,
  473.                                 (rectB.y + rectB.height) - rectA.y);
  474.                     if(t.width > 0 && t.height > 0) {
  475.                         a = new Rectangle(t);
  476.                         rectCount++;
  477.                     }
  478.  
  479.                     t.setBounds(rectA.x, (rectB.y + rectB.height), rectA.width,
  480.                                 (rectA.y + rectA.height) - (rectB.y + rectB.height));
  481.                     if(t.width > 0 && t.height > 0) {
  482.                         b = new Rectangle(t);
  483.                         rectCount++;
  484.                     }
  485.                 } else if ((rectB.y + rectB.height) > (rectA.y + rectA.height)) {
  486.                     t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  487.                     if(t.width > 0 && t.height > 0) {
  488.                         a = new Rectangle(t);
  489.                         rectCount++;
  490.                     }
  491.  
  492.                     t.setBounds(rectA.x, rectB.y, rectB.x - rectA.x,
  493.                                 (rectA.y + rectA.height) - rectB.y);
  494.                     if(t.width > 0 && t.height > 0) {
  495.                         b = new Rectangle(t);
  496.                         rectCount++;
  497.                     }
  498.                 } else {
  499.                     t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  500.                     if(t.width > 0 && t.height > 0) {
  501.                         a = new Rectangle(t);
  502.                         rectCount++;
  503.                     }
  504.  
  505.                     t.setBounds(rectA.x, rectB.y, rectB.x - rectA.x,
  506.                                 rectB.height);
  507.                     if(t.width > 0 && t.height > 0) {
  508.                         b = new Rectangle(t);
  509.                         rectCount++;
  510.                     }
  511.  
  512.                     t.setBounds(rectA.x, (rectB.y + rectB.height), rectA.width,
  513.                                 (rectA.y + rectA.height) - (rectB.y + rectB.height));
  514.                     if(t.width > 0 && t.height > 0) {
  515.                         c = new Rectangle(t);
  516.                         rectCount++;
  517.                     }
  518.                 }
  519.             } else if (rectB.x >= rectA.x && (rectB.x + rectB.width) <= (rectA.x + rectA.width)) {
  520.                 if (rectB.y <= rectA.y && (rectB.y + rectB.height) > (rectA.y + rectA.height)) {
  521.                     t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectA.height);
  522.                     if(t.width > 0 && t.height > 0) {
  523.                         a = new Rectangle(t);
  524.                         rectCount++;
  525.                     }
  526.                     t.setBounds((rectB.x + rectB.width), rectA.y,
  527.                                 (rectA.x + rectA.width) - (rectB.x + rectB.width), rectA.height);
  528.                     if(t.width > 0 && t.height > 0) {
  529.                         b = new Rectangle(t);
  530.                         rectCount++;
  531.                     }
  532.                 } else if (rectB.y <= rectA.y) {
  533.                     t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectA.height);
  534.                     if(t.width > 0 && t.height > 0) {
  535.                         a = new Rectangle(t);
  536.                         rectCount++;
  537.                     }
  538.  
  539.                     t.setBounds(rectB.x, (rectB.y + rectB.height),
  540.                                 rectB.width,
  541.                                 (rectA.y + rectA.height) - (rectB.y + rectB.height));
  542.                     if(t.width > 0 && t.height > 0) {
  543.                         b = new Rectangle(t);
  544.                         rectCount++;
  545.                     }
  546.  
  547.                     t.setBounds((rectB.x + rectB.width), rectA.y,
  548.                                 (rectA.x + rectA.width) - (rectB.x + rectB.width), rectA.height);
  549.                     if(t.width > 0 && t.height > 0) {
  550.                         c = new Rectangle(t);
  551.                         rectCount++;
  552.                     }
  553.                 } else {
  554.                     t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectA.height);
  555.                     if(t.width > 0 && t.height > 0) {
  556.                         a = new Rectangle(t);
  557.                         rectCount++;
  558.                     }
  559.  
  560.                     t.setBounds(rectB.x, rectA.y, rectB.width,
  561.                                 rectB.y - rectA.y);
  562.                     if(t.width > 0 && t.height > 0) {
  563.                         b = new Rectangle(t);
  564.                         rectCount++;
  565.                     }
  566.  
  567.                     t.setBounds((rectB.x + rectB.width), rectA.y,
  568.                                 (rectA.x + rectA.width) - (rectB.x + rectB.width), rectA.height);
  569.                     if(t.width > 0 && t.height > 0) {
  570.                         c = new Rectangle(t);
  571.                         rectCount++;
  572.                     }
  573.                 }
  574.             }
  575.         }
  576.  
  577.         result = new Rectangle[rectCount];
  578.         rectCount = 0;
  579.         if(a != null)
  580.             result[rectCount++] = a;
  581.         if(b != null)
  582.             result[rectCount++] = b;
  583.         if(c != null)
  584.             result[rectCount++] = c;
  585.         if(d != null)
  586.             result[rectCount++] = d;
  587.         return result;
  588.     }
  589.  
  590.     public static boolean isLeftMouseButton(MouseEvent anEvent) {
  591.         return ((anEvent.getModifiers() & InputEvent.BUTTON1_MASK) == InputEvent.BUTTON1_MASK ||
  592.                 (anEvent.getModifiers()  == 0));/*PENDING(ARNAUD) this is to workaround a bug on Solaris */
  593.     }
  594.  
  595.     public static boolean isMiddleMouseButton(MouseEvent anEvent) {
  596.         return ((anEvent.getModifiers() & InputEvent.BUTTON2_MASK) == InputEvent.BUTTON2_MASK);
  597.     }
  598.  
  599.     public static boolean isRightMouseButton(MouseEvent anEvent) {
  600.         return ((anEvent.getModifiers() & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK);
  601.     }
  602.  
  603.     /*
  604.      * Returns whether this is being run on a JDK 1.2 or later VM.
  605.      * This is a system-wide, rather than AppContext-wide, state.
  606.      */
  607.     /*package-private*/ static boolean is1dot2 = true;
  608.  
  609.     static {
  610.         try {
  611.             // Test if method introduced in 1.2 is available.
  612.             Method m = Toolkit.class.getMethod("getMaximumCursorColors", null);
  613.             is1dot2 = (m != null);
  614.         } catch (NoSuchMethodException e) {
  615.             is1dot2 = false;
  616.         }
  617.     }
  618.  
  619.     public static int computeStringWidth(FontMetrics fm,String str) {
  620.         int w[] = fm.getWidths();
  621.         int i,c;
  622.         int result = 0;
  623.         char ch;
  624.         for(i=0,c=str.length() ; i < c ; i++) {
  625.             ch = str.charAt(i);
  626.             if(ch > 255)
  627.                 return fm.stringWidth(str);
  628.             else
  629.                 result += w[(int)ch];
  630.         }
  631.         return result;
  632.     }
  633.  
  634.     /**
  635.      * Compute and return the location of the icons origin, the
  636.      * location of origin of the text baseline, and a possibly clipped
  637.      * version of the compound labels string.  Locations are computed
  638.      * relative to the viewR rectangle.
  639.      */
  640.     public static String layoutCompoundLabel(
  641.         FontMetrics fm,
  642.         String text,
  643.         Icon icon,
  644.         int verticalAlignment,
  645.         int horizontalAlignment,
  646.         int verticalTextPosition,
  647.         int horizontalTextPosition,
  648.         Rectangle viewR,
  649.         Rectangle iconR,
  650.         Rectangle textR,
  651.         int textIconGap)
  652.     {
  653.         /* Initialize the icon bounds rectangle iconR.
  654.          */
  655.  
  656.         if (icon != null) {
  657.             iconR.width = icon.getIconWidth();
  658.             iconR.height = icon.getIconHeight();
  659.         }
  660.         else {
  661.             iconR.width = iconR.height = 0;
  662.         }
  663.  
  664.         /* Initialize the text bounds rectangle textR.  If a null
  665.          * or and empty String was specified we substitute "" here
  666.          * and use 0,0,0,0 for textR.
  667.          */
  668.  
  669.         boolean textIsEmpty = (text == null) || text.equals("");
  670.  
  671.         if (textIsEmpty) {
  672.             textR.width = textR.height = 0;
  673.             text = "";
  674.         }
  675.         else {
  676.             textR.width = computeStringWidth(fm,text);
  677.             textR.height = fm.getHeight();
  678.         }
  679.  
  680.         /* Unless both text and icon are non-null, we effectively ignore
  681.          * the value of textIconGap.  The code that follows uses the
  682.          * value of gap instead of textIconGap.
  683.          */
  684.  
  685.         int gap = (textIsEmpty || (icon == null)) ? 0 : textIconGap;
  686.  
  687.         if (!textIsEmpty) {
  688.  
  689.             /* If the label text string is too wide to fit within the available
  690.              * space "..." and as many characters as will fit will be
  691.              * displayed instead.
  692.              */
  693.  
  694.             int availTextWidth;
  695.  
  696.             if (horizontalTextPosition == CENTER) {
  697.                 availTextWidth = viewR.width;
  698.             }
  699.             else {
  700.                 availTextWidth = viewR.width - (iconR.width + gap);
  701.             }
  702.  
  703.  
  704.             if (textR.width > availTextWidth) {
  705.                 String clipString = "...";
  706.                 int totalWidth = computeStringWidth(fm,clipString);
  707.                 int nChars;
  708.                 for(nChars = 0; nChars < text.length(); nChars++) {
  709.                     totalWidth += fm.charWidth(text.charAt(nChars));
  710.                     if (totalWidth > availTextWidth) {
  711.                         break;
  712.                     }
  713.                 }
  714.                 text = text.substring(0, nChars) + clipString;
  715.                 textR.width = computeStringWidth(fm,text);
  716.             }
  717.         }
  718.  
  719.  
  720.         /* Compute textR.x,y given the verticalTextPosition and
  721.          * horizontalTextPosition properties
  722.          */
  723.  
  724.         if (verticalTextPosition == TOP) {
  725.             if (horizontalTextPosition != CENTER) {
  726.                 textR.y = 0;
  727.             }
  728.             else {
  729.                 textR.y = -(textR.height + gap);
  730.             }
  731.         }
  732.         else if (verticalTextPosition == CENTER) {
  733.             textR.y = (iconR.height / 2) - (textR.height / 2);
  734.         }
  735.         else { // (verticalTextPosition == BOTTOM)
  736.             if (horizontalTextPosition != CENTER) {
  737.                 textR.y = iconR.height - textR.height;
  738.             }
  739.             else {
  740.                 textR.y = (iconR.height + gap);
  741.             }
  742.         }
  743.  
  744.         if (horizontalTextPosition == LEFT) {
  745.             textR.x = -(textR.width + gap);
  746.         }
  747.         else if (horizontalTextPosition == CENTER) {
  748.             textR.x = (iconR.width / 2) - (textR.width / 2);
  749.         }
  750.         else { // (verticalTextPosition == RIGHT)
  751.             textR.x = (iconR.width + gap);
  752.         }
  753.  
  754.         /* labelR is the rectangle that contains iconR and textR.
  755.          * Move it to its proper position given the labelAlignment
  756.          * properties.
  757.          */
  758.  
  759.         Rectangle labelR = iconR.union(textR);
  760.         int dx, dy;
  761.  
  762.         if (verticalAlignment == TOP) {
  763.             dy = viewR.y - labelR.y;
  764.         }
  765.         else if (verticalAlignment == CENTER) {
  766.             dy = (viewR.y + (viewR.height / 2)) - (labelR.y + (labelR.height / 2));
  767.         }
  768.         else { // (verticalAlignment == BOTTOM)
  769.             dy = (viewR.y + viewR.height) - (labelR.y + labelR.height);
  770.         }
  771.  
  772.         if (horizontalAlignment == LEFT) {
  773.             dx = viewR.x - labelR.x;
  774.         }
  775.         else if (horizontalAlignment == CENTER) {
  776.             dx = (viewR.x + (viewR.width / 2)) - (labelR.x + (labelR.width / 2));
  777.         }
  778.         else { // (horizontalAlignment == RIGHT)
  779.             dx = (viewR.x + viewR.width) - (labelR.x + labelR.width);
  780.         }
  781.  
  782.         /* Translate textR and glypyR by dx,dy.
  783.          */
  784.  
  785.         textR.x += dx;
  786.         textR.y += dy;
  787.  
  788.         iconR.x += dx;
  789.         iconR.y += dy;
  790.  
  791.         return text;
  792.     }
  793.  
  794.  
  795.     /**
  796.      * Paint a component c on an abitrary graphics g in the
  797.      * specified rectangle.  The component is reparented to a private
  798.      * container (whose parent becomes p) which prevents c.validate() and
  799.      * and c.repaint() calls from propogating up the tree.  The intermediate
  800.      * container has no other effect.
  801.      */
  802.     public static void paintComponent(Graphics g, Component c, Container p, int x, int y, int w, int h) {
  803.         getCellRendererPane(c, p).paintComponent(g, c, p, x, y, w, h,false);
  804.     }
  805.  
  806.     public static void paintComponent(Graphics g, Component c, Container p, Rectangle r) {
  807.         paintComponent(g, c, p, r.x, r.y, r.width, r.height);
  808.     }
  809.  
  810.  
  811.     /*
  812.      * Ensure that cell renderer c has a ComponentShell parent and that
  813.      * the shells parent is p.
  814.      */
  815.     private static CellRendererPane getCellRendererPane(Component c, Container p) {
  816.         Container shell = c.getParent();
  817.         if (shell instanceof CellRendererPane) {
  818.             if (shell.getParent() != p) {
  819.                 p.add(shell);
  820.             }
  821.         } else {
  822.             shell = new CellRendererPane();
  823.             shell.add(c);
  824.             p.add(shell);
  825.         }
  826.         return (CellRendererPane)shell;
  827.     }
  828.  
  829.     /**
  830.      * A simple minded look and feel change: ask each node in the tree
  831.      * to updateUI(), i.e. to initialize its UI property with the
  832.      * current look and feel.
  833.      */
  834.     public static void updateComponentTreeUI(Component c) {
  835.         updateComponentTreeUI0(c);
  836.         c.invalidate();
  837.         c.validate();
  838.         c.repaint();
  839.     }
  840.  
  841.     private static void updateComponentTreeUI0(Component c) {
  842.         if (c instanceof JComponent) {
  843.             ((JComponent) c).updateUI();
  844.         }
  845.         Component[] children = null;
  846.         if (c instanceof JMenu) {
  847.             children = ((JMenu)c).getMenuComponents();
  848.         }
  849.         else if (c instanceof Container) {
  850.             children = ((Container)c).getComponents();
  851.         }
  852.         if (children != null) {
  853.             for(int i = 0; i < children.length; i++) {
  854.                 updateComponentTreeUI0(children[i]);
  855.             }
  856.         }
  857.     }
  858.  
  859.  
  860.     /**
  861.      * Causes <i>doRun.run()</i> to be executed asynchronously on the
  862.      * AWT event dispatching thread.  This will happen after all
  863.      * pending AWT events have been processed.  This method should
  864.      * be used when an application thread needs to update the GUI.
  865.      * In the following example the invokeAndWait() calls queues
  866.      * the doHelloWorld Runnable for the event dispatching thread and
  867.      * then prints a message.
  868.      * <pre>
  869.      * Runnable doHelloWorld = new Runnable() {
  870.      *     public void run() {
  871.      *         System.out.println("Hello World on " + Thread.currentThread());
  872.      *     }
  873.      * };
  874.      *
  875.      * SwingUtilities.invokeAndWait(doHelloWorld);
  876.      * System.out.println("Waiting ... ");
  877.      * </pre>
  878.      * If invokeAndWait is called from the event dispatching thread,
  879.      * e.g. from a JButtons ActionListener, the <i>doRun.run()</i> will
  880.      * still be deferred till all pending events have been processed.
  881.      * Note that if the <i>doRun.run()</i> throws an uncaught exception
  882.      * the event dispatching thread will unwind (not the current thread).
  883.      * <p>
  884.      * Additional documentation and examples for this method can be
  885.      * found in <A HREF="http://java.sun.com/products/jfc/swingdoc-archive/threads.html">.
  886.      *
  887.      * @see #invokeAndWait
  888.      */
  889.     public static void invokeLater(Runnable doRun) {
  890.     SystemEventQueueUtilities.postRunnable(doRun, null);
  891.     }
  892.  
  893.  
  894.     /**
  895.      * Causes <i>doRun.run()</i> to be executed synchronously on the
  896.      * AWT event dispatching thread.  This call will block until
  897.      * all pending AWT events have been processed and (then)
  898.      * <i>doRun.run()</i> returns. This method should
  899.      * be used when an application thread needs to update the GUI.
  900.      * It should not be called from the EventDispatchThread.
  901.      * Here's an example that creates a new application thread
  902.      * that uses invokeAndWait() to print a string from the event
  903.      * dispatching thread and then, when that's finished, print
  904.      * a string from the application thread.
  905.      * <pre>
  906.      * final Runnable doHelloWorld = new Runnable() {
  907.      *     public void run() {
  908.      *         System.out.println("Hello World on " + Thread.currentThread());
  909.      *     }
  910.      * };
  911.      *
  912.      * Thread appThread = new Thread() {
  913.      *     public void run() {
  914.      *         try {
  915.      *             SwingUtilities.invokeAndWait(doHelloWorld);
  916.      *         }
  917.      *         catch (Exception e) {
  918.      *           e.printStackTrace();
  919.      *         }
  920.      *         System.out.println("Finished on " + Thread.currentThread());
  921.      *     }
  922.      * };
  923.      * appThread.start();
  924.      * </pre>
  925.      * Note that if the Runnable.run() method throws an uncaught exception
  926.      * (on the event dispatching thread) it's caught and rethrown, as
  927.      * an InvocationTargetException, on the callers thread.
  928.      * <p>
  929.      * Additional documentation and examples for this method can be
  930.      * found in <A HREF="http://java.sun.com/products/jfc/swingdoc-archive/threads.html">.
  931.      *
  932.      * @exception  InterruptedException If we're interrupted while waiting for
  933.      *             the event dispatching thread to finish excecuting <i>doRun.run()</i>
  934.      * @exception  InvocationTargetException  If <i>doRun.run()</i> throws
  935.      *
  936.      * @see #invokeLater
  937.      */
  938.     public static void invokeAndWait(final Runnable doRun)
  939.     throws InterruptedException, InvocationTargetException
  940.     {
  941.     if(isEventDispatchThread ()) {
  942.         throw new Error("Cannot call invokeAndWait from the event dispatcher thread");
  943.     }
  944.  
  945.     Object lock = new Object() {
  946.         public String toString() {
  947.         return "SwingUtilities.invokeAndWait() lock for " + doRun;
  948.         }
  949.     };
  950.  
  951.     Exception exc = null;
  952.     synchronized(lock) {
  953.         exc = SystemEventQueueUtilities.postRunnable(doRun, lock);
  954.         lock.wait();
  955.     }
  956.  
  957.     if (exc != null) {
  958.         throw new InvocationTargetException(exc);
  959.     }
  960.     }
  961.  
  962.  
  963.     private static Class eventDispatchThreadClass = null;
  964.  
  965.     /**
  966.      * @return true if the current thread is an AWT event dispatching thread.
  967.      */
  968.     public static boolean isEventDispatchThread()
  969.     {
  970.         Thread currentThread = Thread.currentThread();
  971.  
  972.         /* The first time we're called on what appears to be the event
  973.          * dispatching thread, we stash the threads class in
  974.          * eventDispatchThreadClass.  Subsequently we effectively
  975.          * return eventDispatchThreadClass instanceof Thread.currentThread().
  976.          */
  977.  
  978.         if (eventDispatchThreadClass == null) {
  979.             Class currentThreadClass = currentThread.getClass();
  980.  
  981.             /* This test is a crock.  It's known to work on all of the popular
  982.              * JDK1.1 implementations available as of January 1998.
  983.              */
  984.             if((currentThreadClass.getName().indexOf("EventDispatchThread") >= 0) ||
  985.                (currentThreadClass.getName().indexOf("JMEventQueue") >= 0)) {
  986.                 eventDispatchThreadClass = currentThreadClass;
  987.                 return true;
  988.             }
  989.             else {
  990.                 return false;
  991.             }
  992.         }
  993.         return eventDispatchThreadClass.isInstance(currentThread);
  994.     }
  995.  
  996.  
  997.     /*
  998.      * --- Accessibility Support ---
  999.      *
  1000.      */
  1001.  
  1002.     /**
  1003.      * Get the index of this object in its accessible parent.
  1004.      *
  1005.      * @return -1 of this object does not have an accessible parent.
  1006.      * Otherwise, the index of the child in its accessible parent.
  1007.      */
  1008.     public static int getAccessibleIndexInParent(Component c) {
  1009.         int index = -1;
  1010.         Container parent = c.getParent();
  1011.         if (parent != null) {
  1012.             Component ca[] = parent.getComponents();
  1013.             for (int i = 0; i < ca.length; i++) {
  1014.                 if (ca[i] instanceof Accessible) {
  1015.                     index++;
  1016.                 }
  1017.                 if (c.equals(ca[i])) {
  1018.                     return index;
  1019.                 }
  1020.             }
  1021.         }
  1022.         return -1;
  1023.     }
  1024.  
  1025.     /**
  1026.      * Returns the Accessible child contained at the local coordinate
  1027.      * Point, if one exists.
  1028.      *
  1029.      * @return the Accessible at the specified location, if it exists
  1030.      */
  1031.     public static Accessible getAccessibleAt(Component c, Point p) {
  1032.         if (c instanceof Accessible) {
  1033.             Accessible a = (Accessible) c;
  1034.             if (a != null) {
  1035.                 AccessibleContext ac = a.getAccessibleContext();
  1036.                 if (ac != null) {
  1037.                     AccessibleComponent acmp;
  1038.                     Point location;
  1039.                     int nchildren = ac.getAccessibleChildrenCount();
  1040.                     for (int i=0; i < nchildren; i++) {
  1041.                         a = ac.getAccessibleChild(i);
  1042.                         if ((a != null)) {
  1043.                             ac = a.getAccessibleContext();
  1044.                             if (ac != null) {
  1045.                                 acmp = ac.getAccessibleComponent();
  1046.                                 if ((acmp != null) && (acmp.isShowing())) {
  1047.                                     location = acmp.getLocation();
  1048.                                     Point np = new Point(p.x-location.x,
  1049.                                                          p.y-location.y);
  1050.                                     if (acmp.contains(np)){
  1051.                                         return a;
  1052.                                     }
  1053.                                 }
  1054.                             }
  1055.                         }
  1056.                     }
  1057.                 }
  1058.             }
  1059.             return (Accessible) c;
  1060.         } else {
  1061.             Component ret = c;
  1062.             if (!c.contains(p.x,p.y)) {
  1063.                 ret = null;
  1064.             } else if (c instanceof Container) {
  1065.                 Container cnt = (Container) c;
  1066.                 int ncomponents = cnt.getComponentCount();
  1067.                 for (int i=0; i < ncomponents; i++) {
  1068.                     Component comp = cnt.getComponent(i);
  1069.                     if ((comp != null) && comp.isShowing()) {
  1070.                         Point location = comp.getLocation();
  1071.                         if (comp.contains(p.x-location.x,p.y-location.y)) {
  1072.                             ret = comp;
  1073.                         }
  1074.                     }
  1075.                 }
  1076.             }
  1077.             if (ret instanceof Accessible) {
  1078.                 return (Accessible) ret;
  1079.             }
  1080.         }
  1081.         return null;
  1082.     }
  1083.  
  1084.     /**
  1085.      * Get the state of this object.
  1086.      *
  1087.      * @return an instance of AccessibleStateSet containing the current state
  1088.      * set of the object
  1089.      * @see AccessibleState
  1090.      */
  1091.     public static AccessibleStateSet getAccessibleStateSet(Component c) {
  1092.         AccessibleStateSet states = new AccessibleStateSet();
  1093.         if (c.isEnabled()) {
  1094.             states.add(AccessibleState.ENABLED);
  1095.         }
  1096.         if (c.isFocusTraversable()) {
  1097.             states.add(AccessibleState.FOCUSABLE);
  1098.         }
  1099.         if (c.isVisible()) {
  1100.             states.add(AccessibleState.VISIBLE);
  1101.         }
  1102.         if (c.isShowing()) {
  1103.             states.add(AccessibleState.SHOWING);
  1104.         }
  1105.         // [[[FIXME:  WDW - for JDK1.2 this code can be replaced with
  1106.         //            c.hasFocus()]]]
  1107.         for (Container p = c.getParent(); p != null; p = p.getParent()) {
  1108.             if (p instanceof Window) {
  1109.                 if (((Window)p).getFocusOwner() == c) {
  1110.                     states.add(AccessibleState.FOCUSED);
  1111.                 }
  1112.             }
  1113.         }
  1114.         if (c instanceof Accessible) {
  1115.             AccessibleContext ac = ((Accessible) c).getAccessibleContext();
  1116.             if (ac != null) {
  1117.                 Accessible ap = ac.getAccessibleParent();
  1118.                 if (ap != null) {
  1119.                     AccessibleContext pac = ap.getAccessibleContext();
  1120.                     if (pac != null) {
  1121.                         AccessibleSelection as = pac.getAccessibleSelection();
  1122.                         if (as != null) {
  1123.                             states.add(AccessibleState.SELECTABLE);
  1124.                             int i = ac.getAccessibleIndexInParent();
  1125.                             if (i >= 0) {
  1126.                                 if (as.isAccessibleChildSelected(i)) {
  1127.                                     states.add(AccessibleState.SELECTED);
  1128.                                 }
  1129.                             }
  1130.                         }
  1131.                     }
  1132.                 }
  1133.             }
  1134.         }
  1135.         if (c instanceof JComponent) {
  1136.             if (((JComponent) c).isOpaque()) {
  1137.                 states.add(AccessibleState.OPAQUE);
  1138.             }
  1139.         }
  1140.         return states;
  1141.     }
  1142.  
  1143.     /**
  1144.      * Returns the number of accessible children in the object.  If all
  1145.      * of the children of this object implement Accessible, than this
  1146.      * method should return the number of children of this object.
  1147.      *
  1148.      * @return the number of accessible children in the object.
  1149.      */
  1150.     public static int getAccessibleChildrenCount(Component c) {
  1151.         int count = 0;
  1152.         if (c instanceof Container) {
  1153.             Component[] children = ((Container) c).getComponents();
  1154.             for (int i = 0; i < children.length; i++) {
  1155.                 if (children[i] instanceof Accessible) {
  1156.                     count++;
  1157.                 }
  1158.             }
  1159.         }
  1160.         return count;
  1161.     }
  1162.  
  1163.     /**
  1164.      * Return the nth Accessible child of the object.
  1165.      *
  1166.      * @param i zero-based index of child
  1167.      * @return the nth Accessible child of the object
  1168.      */
  1169.     public static Accessible getAccessibleChild(Component c, int i) {
  1170.         if (c instanceof Container) {
  1171.             Component[] children = ((Container) c).getComponents();
  1172.             int count = 0;
  1173.             for (int j = 0; j < children.length; j++) {
  1174.                 if (children[j] instanceof Accessible) {
  1175.                     if (count == i) {
  1176.                         return (Accessible) children[j];
  1177.                     } else {
  1178.                         count++;
  1179.                     }
  1180.                 }
  1181.             }
  1182.         }
  1183.         return null;
  1184.     }
  1185.  
  1186.     /**
  1187.      * Return the child component which has focus, if any.  The HotJava
  1188.      * SecurityManager forbids applet access to getFocusOwner(), so if the
  1189.      * component is an applet, we check whether a JComponent has focus.
  1190.      * Non-Swing components in an applet on HotJava are out-of-luck,
  1191.      * unfortunately.
  1192.      */
  1193.     public static Component findFocusOwner(Component c) {
  1194.         if (c instanceof Window) {
  1195.             return ((Window)c).getFocusOwner();
  1196.         }
  1197.  
  1198.         if (c instanceof JComponent && ((JComponent)c).hasFocus()) {
  1199.             return c;
  1200.         }
  1201.         if (c instanceof Container) {
  1202.             int n = ((Container)c).countComponents();
  1203.             for (int i = 0; i < n; i++) {
  1204.                 Component focusOwner =
  1205.                     findFocusOwner(((Container)c).getComponent(i));
  1206.                 if (focusOwner != null) {
  1207.                     return focusOwner;
  1208.                 }
  1209.             }
  1210.             return null;
  1211.         } else {
  1212.             return null;  // Component doesn't have hasFocus().
  1213.         }
  1214.     }
  1215.  
  1216.     /**
  1217.      * If c is a JRootPane descendant return its JRootPane ancestor.
  1218.      * If c is a RootPaneContainer then return its JRootPane.
  1219.      * @return the JRootPane for Component c or null.
  1220.      */
  1221.     public static JRootPane getRootPane(Component c) {
  1222.     if (c instanceof RootPaneContainer) {
  1223.         return ((RootPaneContainer)c).getRootPane();
  1224.     }
  1225.     for( ; c != null; c = c.getParent()) {
  1226.         if (c instanceof JRootPane) {
  1227.         return (JRootPane)c;
  1228.         }
  1229.     }
  1230.     return null;
  1231.     }
  1232.  
  1233.  
  1234.     /**
  1235.      * @return the first ancestor of c that's a Window or the last Applet ancestor.
  1236.      */
  1237.     public static Component getRoot(Component c) {
  1238.     Component applet = null;
  1239.     for(Component p = c; p != null; p = p.getParent()) {
  1240.         if (p instanceof Window) {
  1241.         return p;
  1242.         }
  1243.         if (p instanceof Applet) {
  1244.         applet = p;
  1245.         }
  1246.     }
  1247.     return applet;
  1248.     }
  1249.  
  1250.     
  1251.  
  1252.     // Don't use String, as it's not guaranteed to be unique in a Hashtable.
  1253.     private static final Object sharedOwnerFrameKey =
  1254.        new StringBuffer("SwingUtilities.sharedOwnerFrame");
  1255.  
  1256.     /**
  1257.      * Returns a toolkit-private, shared, invisible Frame
  1258.      * to be the owner for JDialogs and JWindows created with
  1259.      * null owners.
  1260.      */
  1261.     static Frame getSharedOwnerFrame() {
  1262.         Frame sharedOwnerFrame =
  1263.             (Frame)SwingUtilities.appContextGet(sharedOwnerFrameKey);
  1264.         if (sharedOwnerFrame == null) {
  1265.             sharedOwnerFrame = new Frame() {
  1266.                 public void show() {
  1267.                     // This frame can never be shown
  1268.                 }
  1269.                 public synchronized void dispose() {
  1270.                     try {
  1271.                         getToolkit().getSystemEventQueue();
  1272.                         super.dispose();
  1273.                     } catch (Exception e) {
  1274.                         // untrusted code not allowed to dispose
  1275.                     }
  1276.                 }
  1277.             };
  1278.             SwingUtilities.appContextPut(sharedOwnerFrameKey,
  1279.                                          sharedOwnerFrame);
  1280.         }
  1281.         return sharedOwnerFrame;
  1282.     }
  1283.  
  1284.     // The following static var and methods are a temporary
  1285.     // workaround for a Solaris bug where disposing modal dialogs
  1286.     // can sometimes cause a segmentation violation. Once this
  1287.     // AWT bug is fixed and available in browsers, we can remove
  1288.     // this workaround.
  1289.     private static final Object dialogsKey =
  1290.         new StringBuffer("SwingUtilities.dialogs");
  1291.  
  1292.     static JDialog getRecycledModalDialog(Frame frame, String title) {
  1293.         Vector dialogs = (Vector)SwingUtilities.appContextGet(dialogsKey);
  1294.         if (dialogs == null) {
  1295.             dialogs = new Vector();
  1296.             SwingUtilities.appContextPut(dialogsKey, dialogs);
  1297.         }
  1298.         JDialog dialog = null;
  1299.         synchronized(dialogs) {
  1300.             for(int i = 0; i < dialogs.size(); i++) {
  1301.                 dialog = (JDialog)dialogs.elementAt(i);
  1302.                 if (dialog.getParent() == frame) {
  1303.                     //System.out.println("Found available dialog: "+dialog);
  1304.                     dialogs.removeElement(dialog);
  1305.                     dialog.setTitle(title);
  1306.                     return dialog;
  1307.                 }
  1308.             }
  1309.             dialog = new JDialog(frame, title, true);
  1310.             //System.out.println("Created new dialog: "+dialog);
  1311.         }
  1312.         return dialog;
  1313.     }
  1314.  
  1315.     static void recycleModalDialog(JDialog dialog) {
  1316.         Vector dialogs = (Vector)SwingUtilities.appContextGet(dialogsKey);
  1317.         synchronized(dialogs) {
  1318.             dialog.getContentPane().removeAll();
  1319.             dialogs.addElement(dialog);
  1320.         }
  1321.     }
  1322.  
  1323.  
  1324.     /* Don't make these AppContext accessors public or protected --
  1325.      * since AppContext is in sun.awt in 1.2, we shouldn't expose it
  1326.      * even indirectly with a public API.
  1327.      */
  1328.     static Hashtable appContextTable = new Hashtable(2);
  1329.  
  1330.     static Object appContextGet(Object key) {
  1331.         /*if[JDK1.2]
  1332.         return sun.awt.AppContext.getAppContext().get(key);
  1333.     else[JDK1.2]*/
  1334.     return appContextTable.get(key);
  1335.         /*end[JDK1.2]*/    
  1336.     }
  1337.  
  1338.     static void appContextPut(Object key, Object value) {
  1339.         /*if[JDK1.2]
  1340.         sun.awt.AppContext.getAppContext().put(key, value);
  1341.     else[JDK1.2]*/
  1342.     appContextTable.put(key, value);
  1343.         /*end[JDK1.2]*/    
  1344.     }
  1345.  
  1346.     static void appContextRemove(Object key) {
  1347.         /*if[JDK1.2]
  1348.         sun.awt.AppContext.getAppContext().remove(key);
  1349.     else[JDK1.2]*/
  1350.     appContextTable.remove(key);
  1351.         /*end[JDK1.2]*/    
  1352.     }
  1353.  
  1354.     /**
  1355.      * Marks the calling thread's stack frame as "privileged" on 1.2 and
  1356.      * higher VMs.  This call has no effect on 1.1.
  1357.      */
  1358.     final static void beginPrivileged() {
  1359.         /*if[JDK1.2]
  1360.           java.security.AccessController.beginPrivileged();
  1361.           end[JDK1.2]*/
  1362.     }
  1363.  
  1364.     /**
  1365.      * Unmarks the calling thread's stack frame, indicating it is no longer
  1366.      * "privileged". This call may only be done
  1367.      * in the same frame as the <code>beginPrivileged</code> call.  This
  1368.      * call has no effect on 1.1.
  1369.      */
  1370.     final static void endPrivileged() {
  1371.         /*if[JDK1.2]
  1372.           java.security.AccessController.endPrivileged();
  1373.           end[JDK1.2]*/
  1374.     }
  1375. }
  1376.